//TCP服务器封装

#ifndef TCP_SERVER_H 
#define TCP_SERVER_H 

#include <memory>
#include <functional>
#include "address.h"
#include "IOmanager.h"
#include "socket.h"
#include "noncopyable.h"
#include "config.h"

namespace framework
{

struct TcpServerConf
{
public:
    using ptr = std::shared_ptr<TcpServerConf>;
private:
};

//TCP服务器
class TcpServer: public std::enable_shared_from_this<TcpServer>
               , Noncopyable
{
public:
    using ptr = std::shared_ptr<TcpServer>;

    //worker socket客户端工作的协程调度器
    //accept_worker 服务器socket执行接收socket连接的协程调度器
    TcpServer(IOManager* worker = IOManager::GetThis()
              ,IOManager* io_woker = IOManager::GetThis()
              ,IOManager* accept_worker = IOManager::GetThis());

    ~TcpServer();

        /**
     * @brief 绑定地址
     * @return 返回是否绑定成功
     */
    virtual bool bind(Address::ptr addr, bool ssl = false);

    /**
     * @brief 绑定地址数组
     * @param[in] addrs 需要绑定的地址数组
     * @param[out] fails 绑定失败的地址
     * @return 是否绑定成功
     */
    virtual bool bind(const std::vector<Address::ptr>& addrs
                        ,std::vector<Address::ptr>& fails
                        ,bool ssl = false);

    bool loadCertificates(const std::string& cert_file, const std::string& key_file);

    /**
     * @brief 启动服务(启动accept)
     * @pre 需要bind成功后执行
     */
    virtual bool start();

    /**
     * @brief 停止服务
     */
    virtual void stop();

    /**
     * @brief 返回读取超时时间(毫秒)
     */
    uint64_t getRecvTimeout() const { return m_recvTimeout;}

    /**
     * @brief 返回服务器名称
     */
    std::string getName() const { return m_name;}

    /**
     * @brief 设置读取超时时间(毫秒)
     */
    void setRecvTimeout(uint64_t v) { m_recvTimeout = v;}

    /**
     * @brief 设置服务器名称
     */
    virtual void setName(const std::string& v) { m_name = v;}

    /**
     * @brief 是否停止
     */
    bool isStop() const { return m_isStop;}

    //获取TcpServerConf
    TcpServerConf::ptr getConf() const { return m_conf;}
    //设置TcpServerConf
    void setConf(TcpServerConf::ptr v) { m_conf = v;}
    //设置TcpServerConf
    void setConf(const TcpServerConf& v);

    virtual std::string toString(const std::string& prefix = "");

    //获取socket数组
    std::vector<Socket::ptr> getSocks() const { return m_socks;}

private:

    //客户端连接成功的回调函数  处理新连接的Socket类
    virtual void handleClient(Socket::ptr client);

    //开始接受连接
    virtual void startAccept(Socket::ptr sock);
private:
    std::vector<Socket::ptr> m_socks; //监听socket的数组（肯能监听多个地址）
    IOManager*  m_worker;        //处理新连接的工作调度器
    IOManager*  m_ioWorker;      
    IOManager*  m_acceptWorker;  //用于处理accept的协程调度器
    uint64_t    m_recvTimeout;   //接收超时时间（毫秒）
    std::string m_name;          //服务器名称
    std::string m_type = "tcp";  //服务器类型
    bool        m_isStop;        //服务器是否停止

    bool m_ssl = false;
    TcpServerConf::ptr m_conf;

};

}   //framework



#endif	/* TCP_SERVER_H */
